#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL.mezcla import strSelectMezcla, strSelectFiltroMezcla
from strSQL.basicas import strNextValCodigo


from psycopg2 import connect
import completion
import comunes
from pyBusqueda import pyBusqueda
import proceso
import treetohtml


(CODIGO_MEZCLA,
 CODIGO_ESTANQUE,
 DESCRIPCION_ESTANQUE,
 FECHA,
 HORA,
 VOLUMEN_MEZCLA,
 CODIGO_INTERNO,
 OBSERVACION,
 ORIGEN,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(11)

class wnMezcla(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnProceso"):
        GladeConnect.__init__(self, "glade/wnProceso.glade", root)
        if padre is None:
            self.wnProceso.set_title("Mezcla")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnProceso.maximize()
            self.frm_padre = self.wnProceso
            self.frm_padre.set_title("Mezcla")

        else:
            self.frm_padre = padre.frm_padre
            
        self.crea_columnas()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_MEZCLA, "Código", "str"])
        columnas.append ([DESCRIPCION_ESTANQUE, "Estanque", "str"])
        columnas.append ([FECHA, "Fecha","dte"])
        columnas.append ([HORA, "Hora", "time"])
        columnas.append ([CODIGO_INTERNO, "Código interno", "str"])
        columnas.append ([OBSERVACION, "Observación", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeProceso)
        self.col_data = [(x[0],x[2]) for x in columnas]
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeProceso,"Mezcla", self.col_data)
        t.show()
        
    def carga_datos(self):
        self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectMezcla)
        self.treeProceso.set_model(self.modelo)

    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgMezcla(self.cnx, self.frm_padre, False)
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        dlg.entFecha.set_date(datetime.date.today())
        dlg.entHora.set_text("%s:%s" % (hora, minuto))
        dlg.editando = False
        response = dlg.dlgMezcla.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
    
    def on_btnQuitar_clicked(self, btn=None):
        
        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        
        selection = self.treeProceso.get_selection()
        model, it = selection.get_selected()
        codigo = model.get_value(it, CODIGO_MEZCLA)
        cuartel = model.get_value(it, DESCRIPCION_ESTANQUE)
        fecha = model.get_value(it, FECHA).split()[0]
        
        if dialogos.yesno("¿Desea eliminar la Mezcla <b>%s, cuartel %s del %s</b>?\nEsta acción no se puede deshacer\n" % (codigo, cuartel, fecha), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'codigo_mezcla':codigo}
            
            
            self.cursor.execute("begin")
            try:
                sql = ifd.deleteFromDict("traza.detalle_mezcla", llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict("traza.fermentacion_mezcla", llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.control', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.aplicacion_producto', llaves)
                self.cursor.execute(sql, llaves)
                sql = ifd.deleteFromDict('traza.mezcla', llaves)
                self.cursor.execute(sql, llaves)
                model.remove(it)
                self.cursor.execute("commit")
            except:
                self.cursor.execute("rollback")
                print sys.exc_info()[1]
                dialogos.error("<b>NO SE PUEDE ELIMINAR\nEl Cuartel %s del %s</b>"%(cuartel, fecha))
        
    def on_btnPropiedades_clicked(self, btn=None):

        model, it = self.treeProceso.get_selection().get_selected()
        if model is None or it is None:
            return
        dlg = dlgMezcla(self.cnx, self.frm_padre, False, codigo_mezcla=model.get_value(it, CODIGO_MEZCLA))
        dlg.editando = True
        dlg.entCodigoMezcla.set_text(model.get_value(it, CODIGO_MEZCLA))
        dlg.entCodigoInterno.set_text(model.get_value(it, CODIGO_INTERNO))
        dlg.codigo_estanque = dlg.pecEstanque.select(model.get_value(it, DESCRIPCION_ESTANQUE), 1)
        dlg.spnVolumen.set_value(float(model.get_value(it, VOLUMEN_MEZCLA)))

        dlg.chkOrigen.set_active(model.get_value(it, ORIGEN) == "S")
        
        fecha = comunes.GetDateFromModel(model.get_value(it, FECHA).split()[0])
        hora = model.get_value(it, HORA).split(":")[0] + ":" + model.get_value(it, HORA).split(":")[1]
        
        dlg.entFecha.set_date(fecha)
        dlg.entHora.set_text(hora)
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        buf = dlg.txtObservacion.get_buffer()
        texto = ""
        if len(model[0]) > OBSERVACION:
            texto = model.get_value(it, OBSERVACION)

        if texto is None:
            texto = ""
        buf.set_text(texto)
        dlg.txtObservacion.set_buffer(buf)
                
        dlg.aplicacion.carga_modelo(model.get_value(it, CODIGO_MEZCLA), "mezcla")
        dlg.control.carga_modelo(model.get_value(it, CODIGO_MEZCLA), "mezcla")
        
        dlg.relacion.carga_modelo(model.get_value(it, CODIGO_MEZCLA))
        
        dlg.detalle.carga_modelo(model.get_value(it, CODIGO_MEZCLA))
        where = "WHERE m.codigo_mezcla <> %s" % model.get_value(it, CODIGO_MEZCLA)
        dlg.detalle.filtro = strSelectFiltroMezcla % where
        
        
        response = dlg.dlgMezcla.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()
            
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Mezcla")
            
    def on_treeProceso_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()


class dlgMezcla(GladeConnect):
    
    def __init__(self, conexion=None, padre=None, editando=None, codigo_mezcla=None):
        GladeConnect.__init__(self, "glade/wnProceso.glade", "dlgMezcla")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.editando = editando
        self.frm_padre = padre
        self.codigo_estanque = None
        
        self.pecEstanque = completion.CompletionEstanque(self.entEstanque,
                self.sel_estanque,
                self.cnx)
        
        self.aplicacion = proceso.vboxAplicacion(self.cnx, self)
        self.ntbMezcla.append_page(self.aplicacion.vboxAplicacion, gtk.Label("Aplicación"))
        
        self.control = proceso.vboxControl(self.cnx, self)
        self.ntbMezcla.append_page(self.control.vboxControl, gtk.Label("Control"))
        
        self.relacion = proceso.vboxMezclaFermentacion(self.cnx, self)
        self.ntbMezcla.append_page(self.relacion.vboxRelacion, gtk.Label("Detalle Fermentación"))
        
        self.detalle = proceso.vboxDetalleMezcla(self.cnx, self, codigo=CODIGO_MEZCLA)
        self.ntbMezcla.append_page(self.detalle.vboxRelacion, gtk.Label("Detalle Mezcla"))
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.dlgMezcla.show_all()

    def on_chkOrigen_toggled(self, btn=None):

        self.relacion.vboxRelacion.set_sensitive(not btn.get_active())
        if btn.get_active():
            self.relacion.modelo_relacion.clear()

        self.relacion.vboxRelacion.set_sensitive(not btn.get_active())
        self.detalle.vboxRelacion.set_sensitive(not btn.get_active())
        self.spnVolumen.set_sensitive(btn.get_active())
        if btn.get_active():
            self.detalle.modelo_relacion.clear()
            self.relacion.modelo_relacion.clear()

    def sel_estanque(self, completion, model, iter):
        self.codigo_estanque = model.get_value(iter, 1)
        
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
        
    def on_btnAceptar_clicked(self, btn=None, date=None, cnx=None):

        fecha = self.entFecha.get_date()
        hora = self.entHora.get_text()
        
        if hora == "":
            dialogos.error("El campo <b>Hora</b> no puede estar vacío")
            return
        
        if self.codigo_estanque is None:
            dialogos.error("Debe escoger un <b>Estanque</b>")
            return
       
        if self.chkOrigen.get_active():
            volumen = self.spnVolumen.get_value()
        else:
            volumen = float(self.relacion.entTotal.get_text()) + float(self.detalle.entTotal.get_text())

        
        if volumen <= 0:
            dialogos.error("El <b>volumen</b> debe ser mayor que 0")
            return
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return
       
        campos = {}
        llaves = {}
        campos['codigo_estanque'] = self.codigo_estanque
        campos['hora_mezcla'] = hora
        campos['volumen'] = volumen
        campos['fecha_mezcla'] = fecha.strftime("%Y/%m/%d")
        campos['codigo_proceso'] = self.entCodigoInterno.get_text()
        campos['codigo_temporada'] = self.codigo_temporada
        
        if self.chkOrigen.get_active():
            origen = "S"
        else:
            origen = "F"
        campos['origen'] = origen
        
        buf = self.txtObservacion.get_buffer()
        s, e = buf.get_bounds()
        if str(buf.get_text(s, e)) != "None" and str(buf.get_text(s, e)) != "":
            campos['orden_trabajo'] = buf.get_text(s, e)
        else:
            buf.set_text("")
            campos['orden_trabajo'] = buf.get_text(s, e)
            
        self.cursor.execute("BEGIN")
        
        try:
        
            if not self.editando:
                self.cursor.execute(strNextValCodigo % ("mezcla", "mezcla"))
                reg = self.cursor.fetchone()
                campos['codigo_mezcla'] = reg[0]
                llaves['codigo_mezcla'] = reg[0]
                sql = ifd.insertFromDict("traza.mezcla", campos)
            else:
                llaves['codigo_mezcla'] = self.entCodigoMezcla.get_text()
                sql, campos=ifd.updateFromDict("traza.mezcla", campos, llaves)
    
            self.cursor.execute(sql, campos)
            self.aplicacion.guarda_modelo(llaves['codigo_mezcla'], "mezcla")
            self.control.guarda_modelo(llaves['codigo_mezcla'], "mezcla")
            self.relacion.guarda_modelo("traza.fermentacion_mezcla", "codigo_mezcla", llaves['codigo_mezcla'], "codigo_fermentacion")
            self.detalle.guarda_modelo("traza.detalle_mezcla", "codigo_mezcla", llaves['codigo_mezcla'], "codigo_relacion")
        except:
            txt_error = sys.exc_info()[1]
            self.cursor.execute("ROLLBACK")
            dialogos.error("Ha ocurrido un error al intentar registrar los datos", str(txt_error))
            return
            
        self.cursor.execute("COMMIT")
        
        self.dlgMezcla.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgMezcla.hide()
        
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnMezcla(cnx)
    
    gtk.main()
